package cn.lsj.lock;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
import org.springframework.util.Assert;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


public class LockScope  implements Scope {

    public static final String LOCK_SCOPE = "lockScope";


    private final Map<String, Object> scopedObjects = new ConcurrentHashMap<>();
//    private final Map<String, Runnable> destructionCallbacks = new ConcurrentHashMap<>();

    /**
     * 用于注册一个回调函数，在Bean对象销毁时执行
     */
    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
//        destructionCallbacks.put(name, callback);
    }

    /**
     * 从作用域中移除指定名称的Bean对象，并返回被移除的对象。如果作用域中不存在该Bean对象，则返回null。
     */
    @Override
    public Object remove(String name) {
        // 注销bean对象的回调，这里直接移除
//        destructionCallbacks.remove(name);
        return scopedObjects.remove(name);
    }

    /**
     * 解析给定的上下文对象。上下文对象是在Bean创建过程中可能需要的其他信息，
     * 例如依赖注入的对象或环境变量。根据给定的键（key），返回相应的上下文对象。在这个方法中，可以根据需要解析上下文对象并返回。
     */
    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    /**
     * 逻辑上相关的一组Bean的集合
     */
    @Override
    public String getConversationId() {
        return LOCK_SCOPE;
    }

    /**
     * 从作用域中获取指定名称的Bean对象
     * @param name 要检索的对象的名称
     * @param objectFactory 用于创建作用域对象（如果它不存在于底层存储机制中）
     */
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Assert.notNull(name, "Scope identifier must not be null");
        Assert.notNull(objectFactory, "ObjectFactory must not be null");
        Object scopedObject = scopedObjects.get(name);
        if (scopedObject == null) {
            return scopedObjects.computeIfAbsent(name, k -> objectFactory.getObject());
        }
        return scopedObject;
    }
}